package ai.zixing.mashibing.advance_class.first.class01;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * 给定一个可能含有重复值的数组arr，i位置的数一定存在如下两个信息
 * 1）arr[i]的左侧离i最近并且小于(或者大于)arr[i]的数在哪？
 * 2）arr[i]的右侧离i最近并且小于(或者大于)arr[i]的数在哪？
 * 如果想得到arr中所有位置的两个信息，怎么能让得到信息的过程尽量快
 */
public class Code03_MonotonousStack {

    /**
     * 无重复值
     * O(N)
     *
     * @param arr 入参数组
     * @return 出参：第 i 位置，左右两个离它最近的且小于它的数，没有则返回 -1
     */
    public static int[][] getNearLessNoRepeat(int[] arr) {
        int[][] res = new int[arr.length][2];
        // 由小到大入栈，栈低值最小,存放的是arr的下标
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < arr.length; i++) {
            // 栈不为空，且当前元素小于栈顶元素，说明当前元素是栈顶元素右边最近的小元素
            while (!stack.isEmpty() && arr[stack.peek()] > arr[i]) {
                // 栈顶元素下标
                int popIndex = stack.pop();
                // 栈顶元素的右边小于它，且最近的元素就是栈顶元素的下一个栈中元素，如果没有，则左侧没有比它小的元素
                int leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
                res[popIndex][0] = leftLessIndex;
                // 栈顶元素的右边小于它，且最近的元素就是当前元素，下标为 i
                res[popIndex][1] = i;
            }
            // 栈为空或者当前下标元素大于栈顶元素
            stack.push(i);
        }
        // 数组遍历完，单独处理栈中的元素.当右边没有比它小的值，不会被释放
        while (!stack.isEmpty()) {
            int popIndex = stack.pop();
            int leftIndex = !stack.isEmpty() ? -1 : stack.peek();
            res[popIndex][0] = leftIndex;
            res[popIndex][1] = -1;
        }
        return res;
    }


    /**
     * 有重复值
     * O(N)
     *
     * @param arr 入参数组
     * @return 出参：第 i 位置，左右两个离它最近的且小于它的数，没有则返回 -1
     */
    public static int[][] getNearLess(int[] arr) {
        int[][] res = new int[arr.length][2];
        // List 中存放的值都一样
        Stack<List<Integer>> stack = new Stack<>();
        for (int i = 0; i < arr.length; i++) {
            // 栈不为空，且栈顶元素大于当前元素，说明当前元素是栈顶元素右侧最进的小元素
            while (!stack.isEmpty() && arr[stack.peek().get(0)] > arr[i]) {
                List<Integer> popList = stack.pop();
                // 取出下宇哥列表中，最后加入的元素下标
                int leftIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);
                for (Integer pop : popList) {
                    res[pop][0] = leftIndex;
                    res[pop][1] = i;
                }
            }
            // 当前元素与栈顶元素下标相等，将当前元素的下标加入栈顶元素的集合中
            if (!stack.isEmpty() && arr[stack.peek().get(0)] == arr[i]) {
                stack.peek().add(i);
            } else {
                // 当前元素大于栈顶元素，构建list，入栈
                List<Integer> curList = new ArrayList<>();
                curList.add(i);
                stack.push(curList);
            }
        }
        // 栈中还有元素
        while (!stack.isEmpty()) {
            List<Integer> popList = stack.pop();
            // 下面是否有值
            int leftIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);
            for (Integer pop : popList) {
                res[pop][0] = leftIndex;
                res[pop][1] = -1;
            }
        }
        return res;
    }
}
